13.17 Java 1.1用户接口API

Java 1.1版同样增加了一些重要的新功能，包括焦点遍历，桌面色彩访问，打印“沙箱内”及早期的剪贴板支持。

焦点遍历十分的简单，因为它显然存在于AWT库里的组件并且我们不必为使它工作而去做任何事。如果我们制造我们自己组件并且想使它们去处理焦点遍历，我们重载isFocusTraversable()以使它返回真值。如果我们想在一个鼠标单击上捕捉键盘焦点，我们可以捕捉鼠标按下事件并且调用requestFocus()需求焦点方法。

13.17.1 桌面颜色

利用桌面颜色，我们可知道当前用户桌面都有哪些颜色选择。这样一来，就可在必要的时候通过自己的程序来运用那些颜色。颜色都会得以自动初始化，并置于SystemColor的static成员中，所以要做的唯一事情就是读取自己感兴趣的成员。各种名字的意义是不言而喻的：desktop，activeCaption， activeCaptionText，activeCaptionBorder， inactiveCaption， inactiveCaptionText，inactiveCaptionBorder， window， windowBorder， windowText， menu，menuText，text， textText， textHighlight， textHighlightText，textInactiveText，control， controlText， controlHighlight，controlLtHighlight，controlShadow，controlDkShadow， scrollbar， info（用于帮助）以及infoText（用于帮助文字）。

13.17.2 打印

非常不幸，打印时没有多少事情是可以自动进行的。相反，为完成打印，我们必须经历大量机械的、非OO（面向对象）的步骤。但打印一个图形化的组件时，可能多少有点儿自动化的意思：默认情况下，print()方法会调用paint()来完成自己的工作。大多数时候这都已经足够了，但假如还想做一些特别的事情，就必须知道页面的几何尺寸。

下面这个例子同时演示了文字和图形的打印，以及打印图形时可以采取的不同方法。此外，它也对打印支持进行了测试：

  1. //: PrintDemo.java
  2. // Printing with Java 1.1
  3. import java.awt.*;
  4. import java.awt.event.*;
  6. public class PrintDemo extends Frame {
  7.   Button
  8.     printText = new Button("Print Text"),
  9.     printGraphics = new Button("Print Graphics");
  10.   TextField ringNum = new TextField(3);
  11.   Choice faces = new Choice();
  12.   Graphics g = null;
  13.   Plot plot = new Plot3(); // Try different plots
  14.   Toolkit tk = Toolkit.getDefaultToolkit();
  15.   public PrintDemo() {
  16.     ringNum.setText("3");
  17.     ringNum.addTextListener(new RingL());
  18.     Panel p = new Panel();
  19.     p.setLayout(new FlowLayout());
  20.     printText.addActionListener(new TBL());
  21.     p.add(printText);
  22.     p.add(new Label("Font:"));
  23.     p.add(faces);
  24.     printGraphics.addActionListener(new GBL());
  25.     p.add(printGraphics);
  26.     p.add(new Label("Rings:"));
  27.     p.add(ringNum);
  28.     setLayout(new BorderLayout());
  29.     add(p, BorderLayout.NORTH);
  30.     add(plot, BorderLayout.CENTER);
  31.     String[] fontList = tk.getFontList();
  32.     for(int i = 0; i < fontList.length; i++)
  33.       faces.add(fontList[i]);
  34.     faces.select("Serif");
  35.   }
  36.   class PrintData {
  37.     public PrintJob pj;
  38.     public int pageWidth, pageHeight;
  39.     PrintData(String jobName) {
  40.       pj = getToolkit().getPrintJob(
  41.         PrintDemo.this, jobName, null);
  42.       if(pj != null) {
  43.         pageWidth = pj.getPageDimension().width;
  44.         pageHeight= pj.getPageDimension().height;
  45.         g = pj.getGraphics();
  46.       }
  47.     }
  48.     void end() { pj.end(); }
  49.   }
  50.   class ChangeFont {
  51.     private int stringHeight;
  52.     ChangeFont(String face, int style,int point){
  53.       if(g != null) {
  54.         g.setFont(new Font(face, style, point));
  55.         stringHeight =
  56.           g.getFontMetrics().getHeight();
  57.       }
  58.     }
  59.     int stringWidth(String s) {
  60.       return g.getFontMetrics().stringWidth(s);
  61.     }
  62.     int stringHeight() { return stringHeight; }
  63.   }
  64.   class TBL implements ActionListener {
  65.     public void actionPerformed(ActionEvent e) {
  66.       PrintData pd =
  67.         new PrintData("Print Text Test");
  68.       // Null means print job canceled:
  69.       if(pd == null) return;
  70.       String s = "PrintDemo";
  71.       ChangeFont cf = new ChangeFont(
  72.         faces.getSelectedItem(), Font.ITALIC,72);
  73.       g.drawString(s,
  74.         (pd.pageWidth - cf.stringWidth(s)) / 2,
  75.         (pd.pageHeight - cf.stringHeight()) / 3);
  77.       s = "A smaller point size";
  78.       cf = new ChangeFont(
  79.         faces.getSelectedItem(), Font.BOLD, 48);
  80.       g.drawString(s,
  81.         (pd.pageWidth - cf.stringWidth(s)) / 2,
  82.         (int)((pd.pageHeight -
  83.            cf.stringHeight())/1.5));
  84.       g.dispose();
  85.       pd.end();
  86.     }
  87.   }
  88.   class GBL implements ActionListener {
  89.     public void actionPerformed(ActionEvent e) {
  90.       PrintData pd =
  91.         new PrintData("Print Graphics Test");
  92.       if(pd == null) return;
  93.       plot.print(g);
  94.       g.dispose();
  95.       pd.end();
  96.     }
  97.   }
  98.   class RingL implements TextListener {
  99.     public void textValueChanged(TextEvent e) {
  100.       int i = 1;
  101.       try {
  102.         i = Integer.parseInt(ringNum.getText());
  103.       } catch(NumberFormatException ex) {
  104.         i = 1;
  105.       }
  106.       plot.rings = i;
  107.       plot.repaint();
  108.     }
  109.   }
  110.   public static void main(String[] args) {
  111.     Frame pdemo = new PrintDemo();
  112.     pdemo.setTitle("Print Demo");
  113.     pdemo.addWindowListener(
  114.       new WindowAdapter() {
  115.         public void windowClosing(WindowEvent e) {
  116.           System.exit(0);
  117.         }
  118.       });
  119.     pdemo.setSize(500, 500);
  120.     pdemo.setVisible(true);
  121.   }
  122. }
  124. class Plot extends Canvas {
  125.   public int rings = 3;
  126. }
  128. class Plot1 extends Plot {
  129.   // Default print() calls paint():
  130.   public void paint(Graphics g) {
  131.     int w = getSize().width;
  132.     int h = getSize().height;
  133.     int xc = w / 2;
  134.     int yc = w / 2;
  135.     int x = 0, y = 0;
  136.     for(int i = 0; i < rings; i++) {
  137.       if(x < xc && y < yc) {
  138.         g.drawOval(x, y, w, h);
  139.         x += 10; y += 10;
  140.         w -= 20; h -= 20;
  141.       }
  142.     }
  143.   }
  144. }
  146. class Plot2 extends Plot {
  147.   // To fit the picture to the page, you must
  148.   // know whether you're printing or painting:
  149.   public void paint(Graphics g) {
  150.     int w, h;
  151.     if(g instanceof PrintGraphics) {
  152.       PrintJob pj =
  153.         ((PrintGraphics)g).getPrintJob();
  154.       w = pj.getPageDimension().width;
  155.       h = pj.getPageDimension().height;
  156.     }
  157.     else {
  158.       w = getSize().width;
  159.       h = getSize().height;
  160.     }
  161.     int xc = w / 2;
  162.     int yc = w / 2;
  163.     int x = 0, y = 0;
  164.     for(int i = 0; i < rings; i++) {
  165.       if(x < xc && y < yc) {
  166.         g.drawOval(x, y, w, h);
  167.         x += 10; y += 10;
  168.         w -= 20; h -= 20;
  169.       }
  170.     }
  171.   }
  172. }
  174. class Plot3 extends Plot {
  175.   // Somewhat better. Separate
  176.   // printing from painting:
  177.   public void print(Graphics g) {
  178.     // Assume it's a PrintGraphics object:
  179.     PrintJob pj =
  180.       ((PrintGraphics)g).getPrintJob();
  181.     int w = pj.getPageDimension().width;
  182.     int h = pj.getPageDimension().height;
  183.     doGraphics(g, w, h);
  184.   }
  185.   public void paint(Graphics g) {
  186.     int w = getSize().width;
  187.     int h = getSize().height;
  188.     doGraphics(g, w, h);
  189.   }
  190.   private void doGraphics(
  191.       Graphics g, int w, int h) {
  192.     int xc = w / 2;
  193.     int yc = w / 2;
  194.     int x = 0, y = 0;
  195.     for(int i = 0; i < rings; i++) {
  196.       if(x < xc && y < yc) {
  197.         g.drawOval(x, y, w, h);
  198.         x += 10; y += 10;
  199.         w -= 20; h -= 20;
  200.       }
  201.     }
  202.   }
  203. } ///:~

这个程序允许我们从一个选择列表框中选择字体（并且我们会注意到很多有用的字体在Java 1.1版中一直受到严格的限制，我们没有任何可以利用的优秀字体安装在我们的机器上）。它使用这些字体去打出粗体，斜体和不同大小的文字。另外，一个新型组件调用过的绘图被创建，以用来示范图形。当打印图形时，绘图拥有的ring将显示在屏幕上和打印在纸上，并且这三个派生类Plot1，Plot2，Plot3用不同的方法去完成任务以便我们可以看到我们选择的事物。同样，我们也能在一个绘图中改变一些ring——这很有趣，因为它证明了Java 1.1版中打印的脆弱。在我的系统里，当ring计数显示too high（究竟这是什么意思？）时，打印机给出错误信息并且不能正确地工作，而当计数给出low enough信息时，打印机又能工作得很好。我们也会注意到，当打印到看起来实际大小不相符的纸时页面的大小便产生了。这些特点可能被装入到将来发行的Java中，我们可以使用这个程序来测试它。

这个程序为促进重复使用，不论何时都可以封装功能到内部类中。例如，不论何时我想开始打印工作（不论图形或文字），我必须创建一个PrintJob打印工作对象，该对象拥有它自己的连同页面宽度和高度的图形对象。创建的PrintJob打印工作对象和提取的页面尺寸一起被封装进PrintData class打印类中。

(1) 打印文字

打印文字的概念简单明了：我们选择一种字体和大小，决定字符串在页面上存在的位置，并且使用Graphics.drawSrting()方法在页面上画出字符串就行了。这意味着，不管怎样我们必须精确地计算每行字符串在页面上存在的位置并确定字符串不会超出页面底部或者同其它行冲突。如果我们想进行字处理，我们将进行的工作与我们很相配。ChangeFont封装进少量从一种字体到其它的字体的变更方法并自动地创建一个新字体对象和我们想要的字体，款式（粗体和斜体——目前还不支持下划线、空心等）以及点阵大小。它同样会简单地计算字符串的宽度和高度。当我们按下Print text按钮时，TBL接收器被激活。我们可以注意到它通过迭代创建ChangeFont对象和调用drawString()来在计算出的位置打印出字符串。注意是否这些计算产生预期的结果。（我使用的版本没有出错。）

(2) 打印图形

按下Print graphics按钮时，GBL接收器会被激活。我们需要打印时，创建的PrintData对象初始化，然后我们简单地为这个组件调用print()打印方法。为强制打印，我们必须为图形对象调用dispose()处理方法，并且为PrintData对象调用end()结束方法（或改变为为PrintJob调用end()结束方法。）

这种工作在绘图对象中继续。我们可以看到基类绘图是很简单的——它扩展画布并且包括一个中断调用ring来指明多少个集中的ring需要画在这个特殊的画布上。这三个派生类展示了可达到一个目的的不同的方法：画在屏幕上和打印的页面上。

Plot1采用最简单的编程方法：忽略绘画和打印的不同，并且重载paint()绘画方法。使用这种工作方法的原因是默认的print()打印方法简单地改变工作方法转而调用Paint()。但是，我们会注意到输出的尺寸依赖于屏幕上画布的大小，因为宽度和高度都是在调用Canvas.getSize()方法时决定是，所以这是合理的。如果我们图像的尺寸一值都是固定不变的，其它的情况都可接受。当画出的外观的大小如此的重要时，我们必须深入了解的尺寸大小的重要性。不凑巧的是，就像我们将在Plot2中看到的一样，这种方法变得很棘手。因为一些我们不知道的好的理由，我们不能简单地要求图形对象以它自己的大小画出外观。这将使整个的处理工作变得十分的优良。相反，如果我们打印而不是绘画，我们必须利用RTTI instanceof关键字（在本书11章中有相应描述）来测试PrintGrapics，然后向下转换并调用这独特的PrintGraphics方法：getPrintJob()方法。现在我们拥有PrintJob的引用并且我们可以发现纸张的高度和宽度。这是一种hacky的方法，但也许这对它来说是合理的理由。（在其它方面，到如今我们看到一些其它的库设计，因此，我们可能会得到设计者们的想法。）

我们可以注意到Plot2中的paint()绘画方法对打印和绘图的可能性进行审查。但是因为当打印时Print()方法将被调用，那么为什么不使用那种方法呢？这种方法同样也在Plot3中也被使用，并且它消除了对instanceof使用的需求，因为在Print()方法中我们可以假设我们能对一个PrintGraphics对象转换。这样也不坏。这种情况被放置公共绘画代码到一个分离的doGraphics()方法的办法所改进。

(2) 在程序片内运行帧

如果我们想在一个程序片中打印会怎以样呢？很好，为了打印任何事物我们必须通过工具组件对象的getPrintJob()方法拥有一个PrintJob对象，设置唯一的一个帧对象而不是一个程序片对象。于是它似乎可能从一个应用程序中打印，而不是从一个程序片中打印。但是，它变为我们可以从一个程序片中创建一个帧（相反的到目前为止，我在程序片或应用程序例子中所做的，都可以生成程序片并安放帧。）。这是一个很有用的技术，因为它允许我们在程序片中使用一些应用程序（只要它们不妨碍程序片的安全）。但是，当应用程序窗口在程序片中出现时，我们会注意到WEB浏览器插入一些警告在它上面，其中一些产生“Warning:Applet Window.（警告：程序片窗口）”的字样。

我们会看到这种技术十分直接的安放一个帧到程序片中。唯一的事是当用户关闭它时我们必须增加帧的代码（代替调用System.exit()）：

  1. //: PrintDemoApplet.java
  2. // Creating a Frame from within an Applet
  3. import java.applet.*;
  4. import java.awt.*;
  5. import java.awt.event.*;
  7. public class PrintDemoApplet extends Applet {
  8.   public void init() {
  9.     Button b = new Button("Run PrintDemo");
  10.     b.addActionListener(new PDL());
  11.     add(b);
  12.   }
  13.   class PDL implements ActionListener {
  14.     public void actionPerformed(ActionEvent e) {
  15.       final PrintDemo pd = new PrintDemo();
  16.       pd.addWindowListener(new WindowAdapter() {
  17.         public void windowClosing(WindowEvent e){
  18.           pd.dispose();
  19.         }
  20.       });
  21.       pd.setSize(500, 500);
  22.       pd.show();
  23.     }
  24.   }
  25. } ///:~

伴随Java 1.1版的打印支持功能而来的是一些混乱。一些宣传似乎声明我们能在一个程序片中打印。但Java的安全系统包含了一个特点，可停止一个正在初始化打印工作的程序片，初始化程序片需要通过一个Web浏览器或程序片浏览器来进行。在写作这本书时，这看起来像留下了一个未定的争议。当我在WEB浏览器中运行这个程序时，printdemo（打印样本）窗口正好出现，但它却根本不能从浏览器中打印。

13.17.3 剪贴板

Java 1.1对系统剪贴板提供有限的操作支持（在Java.awt.datatransfer package里）。我们可以将字符串作这文字对象复制到剪贴板中，并且我们可以从剪贴板中粘贴文字到字符中对角中。当然，剪贴板被设计来容纳各种类型的数据，存在于剪贴板上的数据通过程序运行剪切和粘贴进入到程序中。虽然剪切板目前只支持字符串数据，Java的剪切板API通过“特色”概念提供了良好的可扩展性。当数据从剪贴板中出来时，它拥有一个相关的特色集，这个特色集可以被修改（例如，一个图形可以被表示成一些字符串或者一幅图像）并且我们会注意到如果特殊的剪贴板数据支持这种特色，我们会对此十分的感兴趣。

下面的程序简单地对TextArea中的字符串数据进行剪切，复制，粘贴的操作做了示范。我们将注意到的是我们需要按照剪切、复制和粘贴的顺序进行工作。但如果我们看见一些其它程序中的TextField或者TextArea，我们会发现它们同样也自动地支持剪贴板的操作顺序。程序中简单地增加了剪贴板的程序化控制，如果我们想用它来捕捉剪贴板上的文字到一些非文字组件中就可以使用这种技术。

  1. //: CutAndPaste.java
  2. // Using the clipboard from Java 1.1
  3. import java.awt.*;
  4. import java.awt.event.*;
  5. import java.awt.datatransfer.*;
  7. public class CutAndPaste extends Frame {
  8.   MenuBar mb = new MenuBar();
  9.   Menu edit = new Menu("Edit");
  10.   MenuItem
  11.     cut = new MenuItem("Cut"),
  12.     copy = new MenuItem("Copy"),
  13.     paste = new MenuItem("Paste");
  14.   TextArea text = new TextArea(20,20);
  15.   Clipboard clipbd =
  16.     getToolkit().getSystemClipboard();
  17.   public CutAndPaste() {
  18.     cut.addActionListener(new CutL());
  19.     copy.addActionListener(new CopyL());
  20.     paste.addActionListener(new PasteL());
  21.     edit.add(cut);
  22.     edit.add(copy);
  23.     edit.add(paste);
  24.     mb.add(edit);
  25.     setMenuBar(mb);
  26.     add(text, BorderLayout.CENTER);
  27.   }
  28.   class CopyL implements ActionListener {
  29.     public void actionPerformed(ActionEvent e) {
  30.       String selection = text.getSelectedText();
  31.       StringSelection clipString =
  32.         new StringSelection(selection);
  33.       clipbd.setContents(clipString, clipString);
  34.     }
  35.   }
  36.   class CutL implements ActionListener {
  37.     public void actionPerformed(ActionEvent e) {
  38.       String selection = text.getSelectedText();
  39.       StringSelection clipString =
  40.         new StringSelection(selection);
  41.       clipbd.setContents(clipString, clipString);
  42.       text.replaceRange("",
  43.         text.getSelectionStart(),
  44.         text.getSelectionEnd());
  45.     }
  46.   }
  47.   class PasteL implements ActionListener {
  48.     public void actionPerformed(ActionEvent e) {
  49.       Transferable clipData =
  50.         clipbd.getContents(CutAndPaste.this);
  51.       try {
  52.         String clipString =
  53.           (String)clipData.
  54.             getTransferData(
  55.               DataFlavor.stringFlavor);
  56.         text.replaceRange(clipString,
  57.           text.getSelectionStart(),
  58.           text.getSelectionEnd());
  59.       } catch(Exception ex) {
  60.         System.out.println("not String flavor");
  61.       }
  62.     }
  63.   }
  64.   public static void main(String[] args) {
  65.     CutAndPaste cp = new CutAndPaste();
  66.     cp.addWindowListener(
  67.       new WindowAdapter() {
  68.         public void windowClosing(WindowEvent e) {
  69.           System.exit(0);
  70.         }
  71.       });
  72.     cp.setSize(300,200);
  73.     cp.setVisible(true);
  74.   }
  75. } ///:~

创建和增加菜单及TextArea到如今似乎已变成一种单调的活动。这与通过工具组件创建的剪贴板字段clipbd有很大的区别。

所有的动作都安置在接收器中。CopyL和Cupl接收器同样除了最后的CutL线以外删除被复制的线。特殊的两条线是StringSelection对象从字符串从创建并调用StringSelection的setContents()方法。说得更准确些，就是放一个字符串到剪切板上。

在PasteL中，数据被剪贴板利用getContents()进行分解。任何返回的对象都是可移动的匿名的，并且我们并不真正地知道它里面包含了什么。有一种发现的方法是调用getTransferDateFlavors()，返回一个DataFlavor对象数组，表明特殊对象支持这种特点。我们同样能要求它通过我们感兴趣的特点直接地使用IsDataFlavorSupported()。但是在这里使用一种大胆的方法：调用getTransferData()方法，假设里面的内容支持字符串特色，并且它不是个被分类在异常处理器中的难题 。

在将来，我们希望更多的数据特色能够被支持。